package com.example.sync.utils;

import org.springframework.data.redis.connection.DataType;
import org.springframework.data.redis.core.Cursor;
import org.springframework.data.redis.core.RedisTemplate;
import org.springframework.data.redis.core.ScanOptions;
import org.springframework.data.redis.core.ZSetOperations;

import javax.annotation.Resource;
import java.util.*;
import java.util.concurrent.TimeUnit;

/**
 * @author gaofeng
 * @date 2022年07月04日 0:03
 */
public class RedisUtils {

    @Resource
    private RedisTemplate<String, Object> redisTemplate ;

    public void set(String key, Object value) {
        redisTemplate.opsForValue().set(key ,value);
    }

    public void setWithExpire(String key, Object value, long time, TimeUnit unit) {
        redisTemplate.opsForValue().set(key, value, time, unit);
    }

    public Object get(String key) {
        return redisTemplate.opsForValue().get(key) ;
    }

    public Boolean hasKey(String key) {
        return redisTemplate.hasKey(key) ;
    }

    public Boolean delKey(String key) {
        return redisTemplate.delete(key) ;
    }

    public Long batchDelKeys(Collection<String> keys) {
        return redisTemplate.delete(keys) ;
    }

    /**
     * 把key的值序列化为byte[]
     * @author gaofeng
     * @date  2022/7/4 0:17
     * @param key
     * @return byte[]
     */
    public byte[] dump(String key) {
        return redisTemplate.dump(key) ;
    }

    /**
     * 对传入的 key值设置过期时间
     * @author gaofeng
     * @date  2022/7/4 0:20
     * @param key
     * @param seconds
     * @return java.lang.Boolean
     */
    public Boolean expire(String key, long seconds) {
        return redisTemplate.expire(key, seconds, TimeUnit.SECONDS) ;
    }

    /**
     * 对传入的 key值设置过期日期
     * @author gaofeng
     * @date  2022/7/4 0:20
     * @param key
     * @param date
     * @return java.lang.Boolean
     */
    public Boolean expireAt(String key, Date date) {
        return redisTemplate.expireAt(key, date) ;
    }

    /**
     * 模糊查询，返回一个没有重复的 Set类型
     * @author gaofeng
     * @date  2022/7/4 0:22
     * @param key
     * @return java.util.Set<java.lang.String>
     */
    public Set<String> getStringKeys(String key) {
        return redisTemplate.keys(key) ;
    }

    public void rename(String oldKey, String newKey) {
        redisTemplate.rename(oldKey, newKey);
    }

    public void renameIfAbsent(String oldKey, String newKey) {
        redisTemplate.renameIfAbsent(oldKey, newKey) ;
    }

    public DataType type(String key) {
        return redisTemplate.type(key) ;
    }

    public String randomKey() {
        return redisTemplate.randomKey() ;
    }

    /**
     * 获取当前 key的剩下的过期时间
     * @author gaofeng
     * @date  2022/7/4 0:29
     * @param key
     * @return java.lang.Long
     */
    public Long getExpire(String key) {
        return redisTemplate.getExpire(key) ;
    }

    /**
     * 获取 key剩余的过期时间，同时设置时间单位
     * @author gaofeng
     * @date  2022/7/4 0:30
     * @param key
     * @param unit
     * @return java.lang.Long
     */
    public Long getExpire(String key, TimeUnit unit) {
        return redisTemplate.getExpire(key, unit) ;
    }

    public Boolean persist(String key) {
        return redisTemplate.persist(key) ;
    }

    /**
     *  将当前数据库的 key移动到指定 redis中数据库当中
     * @author chengjunyu
     * @date 2022/2/12
     * @param key
     * @param dbIndex
     * @return java.lang.Boolean
     */
    public Boolean move(String key, int dbIndex) {
        return redisTemplate.move(key, dbIndex);
    }

    /**
     *  截取 key的子字符串
     * @author chengjunyu
     * @date 2022/2/12
     * @param key
     * @param start
     * @param end
     * @return java.lang.String
     */
    public String subString(String key, long start, long end) {
        return redisTemplate.opsForValue().get(key, start, end);
    }

    /**
     *  设置 key跟 value的值，同时获取 key的值
     * @author chengjunyu
     * @date 2022/2/12
     * @param key
     * @param value
     * @return java.lang.Object
     */
    public Object getAndSet(String key, Object value) {
        return redisTemplate.opsForValue().getAndSet(key, value);
    }

    /**
     *  设置多个 key跟 value的值，同时获取 key的值
     * @author chengjunyu
     * @date 2022/2/12
     * @param keys
     * @return java.util.List<java.lang.Object>
     */
    public List<Object> multiGetSet(List<String> keys) {
        return redisTemplate.opsForValue().multiGet(keys);
    }

    /**
     *  获取原来的 key的值后在后面新增上新的字符串
     * @author chengjunyu
     * @date 2022/2/12
     * @param  * @param key
     * @param value
     * @return java.lang.Integer
     */
    public Integer append(String key, String value) {
        return redisTemplate.opsForValue().append(key, value);
    }

    /**
     *  value 值 +1
     * @author chengjunyu
     * @date 2022/2/12
     * @param  * @param key
     * @return java.lang.Long
     */
    public Long increment(String key) {
        return redisTemplate.opsForValue().increment(key);
    }

    /**
     *  增量方式增加或减少 long值
     * @author chengjunyu
     * @date 2022/2/12
     * @param key
     * @param increment
     * @return java.lang.Long
     */
    public Long incrementLong(String key, long increment) {
        return redisTemplate.opsForValue().increment(key, increment);
    }

    /**
     *  增量方式增加double值
     * @author chengjunyu
     * @date 2022/2/12
     * @param key
     * @param increment
     * @return void
     */
    public void incrementDouble(String key, double increment) {
        redisTemplate.opsForValue().increment(key, increment);
    }

    /**
     *  不存在即新增map的操作
     * @author chengjunyu
     * @date 2022/2/12
     * @param  * @param map
     * @return java.lang.Boolean
     */
    public Boolean multiSetIfAbsent(Map<? extends String, ?> map) {
        return redisTemplate.opsForValue().multiSetIfAbsent(map);
    }

    /**
     *  保存 map集合
     * @author chengjunyu
     * @date 2022/2/12
     * @param  * @param map
     * @return void
     */
    public void multiSet(Map<String, String> map) {
        redisTemplate.opsForValue().multiSet(map);
    }

    /**
     *  获取 map集合
     * @author chengjunyu
     * @date 2022/2/12
     * @param  * @param keys
     * @return java.util.List<java.lang.Object>
     */
    public List<Object> multiGet(List<String> keys) {
        return redisTemplate.opsForValue().multiGet(keys);
    }

    /**
     *  获取指定 key的字符串的长度
     * @author chengjunyu
     * @date 2022/2/12
     * @param key
     * @return java.lang.Long
     */
    public Long sizeString(String key) {
        return redisTemplate.opsForValue().size(key);
    }

    /**
     *  根据偏移量 offset 的值，覆盖重写 value的值
     * @author chengjunyu
     * @date 2022/2/12
     * @param key
     * @param value
     * @param offset
     * @return void
     */
    public void offsetValue(String key, Object value, Long offset) {
        redisTemplate.opsForValue().set(key, value, offset);
    }

    /**
     *  对 key所储存的字符串值，获取指定偏移量上的位(bit)
     * @author chengjunyu
     * @date 2022/2/12
     * @param key
     * @param offset
     * @return java.lang.Boolean
     */
    public Boolean getOffsetValue(String key, Long offset) {
        return redisTemplate.opsForValue().getBit(key, offset);
    }

    /**
     *  重新设置 key对应的值，如果存在返回 false，否则返回 true
     * @author chengjunyu
     * @date 2022/2/12
     * @param key
     * @param value
     * @return java.lang.Boolean
     */
    public Boolean setIfAbsent(String key, Object value) {
        return redisTemplate.opsForValue().setIfAbsent(key, value);
    }

    /**
     *  新增map值
     * @author chengjunyu
     * @date 2022/2/12
     * @param key
     * @param field
     * @param value
     * @return void
     */
    public void put(String key, Object field, Object value) {
        redisTemplate.opsForHash().put(key, field, value);
    }

    /**
     *  以map集合的形式添加键值对
     * @author chengjunyu
     * @date 2022/2/12
     * @param key
     * @param map
     * @return void
     */
    public void putAll(String key, Map<Object, Object> map) {
        redisTemplate.opsForHash().putAll(key, map);
    }

    /**
     *  获取 map中指定的 key值，如果存在则返回值，没有就返回null
     * @author chengjunyu
     * @date 2022/2/12
     * @param key
     * @param field
     * @return java.lang.Object
     */
    public Object getMapValue(String key, String field) {
        return redisTemplate.opsForHash().get(key, field);
    }

    /**
     *  根据 key获取 Map对象
     * @author chengjunyu
     * @date 2022/2/12
     * @param  * @param key
     * @return java.util.Map<java.lang.Object,java.lang.Object>
     */
    public Map<Object, Object> getMap(String key) {
        return redisTemplate.opsForHash().entries(key);
    }

    /**
     *  当 hashKey不存在的时候，进行设置 map的值
     * @author chengjunyu
     * @date 2022/2/12
     * @param key
     * @param hashKey
     * @param value
     * @return java.lang.Boolean
     */
    public Boolean putIfAbsent(String key, Object hashKey, Object value) {
        return redisTemplate.opsForHash().putIfAbsent(key, hashKey, value);
    }

    /**
     *  删除多个map的字段
     * @author chengjunyu
     * @date 2022/2/12
     * @param key
     * @param fields
     * @return java.lang.Long
     */
    public Long del(String key, List<Object> fields) {
        return redisTemplate.opsForHash().delete(key, fields);
    }

    /**
     *  查看 hash表中指定字段是否存在
     * @author chengjunyu
     * @date 2022/2/12
     * @param  * @param key
     * @param field
     * @return java.lang.Boolean
     */
    public Boolean hasKey(String key, Object field) {
        return redisTemplate.opsForHash().hasKey(key, field);
    }

    /**
     *  给 map中指定字段的整数值加上 long型增量 increment
     * @author chengjunyu
     * @date 2022/2/12
     * @param key
     * @param field
     * @param increment
     * @return java.lang.Long
     */
    public Long incrementLong(String key, Object field, long increment) {
        return redisTemplate.opsForHash().increment(key, field, increment);
    }

    /**
     *  给 map中指定字段的整数值加上 double型增量 increment
     * @author chengjunyu
     * @date 2022/2/12
     * @param key
     * @param field
     * @param increment
     * @return java.lang.Double
     */
    public Double incrementDouble(String key, Object field, double increment) {
        return redisTemplate.opsForHash().increment(key, field, increment);
    }

    /**
     *  获取 map中的所有字段
     * @author chengjunyu
     * @date 2022/2/12
     * @param key
     * @return java.util.Set<java.lang.Object>
     */
    public Set<Object> keys(String key) {
        return redisTemplate.opsForHash().keys(key);
    }

    /**
     *  获取 map中所有字段的数量
     * @author chengjunyu
     * @date 2022/2/12
     * @param key
     * @return java.util.Set<java.lang.Object>
     */
    public Long sizeHash(String key) {
        return redisTemplate.opsForHash().size(key);
    }

    /**
     *  获取hash表中存在的所有的值
     * @author chengjunyu
     * @date 2022/2/12
     * @param key
     * @return java.util.List<java.lang.Object>
     */
    public List<Object> values(String key) {
        return redisTemplate.opsForHash().values(key);
    }

    /**
     *  查看匹配的键值对
     * @author chengjunyu
     * @date 2022/2/12
     * @param key
     * @param scanOptions
     * @return org.springframework.data.redis.core.Cursor<java.util.Map.Entry<java.lang.Object,java.lang.Object>>
     */
    public Cursor<Map.Entry<Object, Object>> scan(String key, ScanOptions scanOptions) {
        return redisTemplate.opsForHash().scan(key, scanOptions);
    }

    /**
     *  把值添加在 list的最前面
     * @author chengjunyu
     * @date 2022/2/12
     * @param key
     * @param value
     * @return java.lang.Long
     */
    public Long leftPush(String key, Object value) {
        return redisTemplate.opsForList().leftPush(key, value);
    }

    /**
     *  把值添加在 list
     * @author chengjunyu
     * @date 2022/2/12
     * @param key
     * @param values
     * @return java.lang.Long
     */
    public Long leftPush(String key, Object... values) {
        return redisTemplate.opsForList().leftPushAll(key, values);
    }

    /**
     *  直接把一个新的 list添加到老的 list上面去
     * @author chengjunyu
     * @date 2022/2/12
     * @param key
     * @param value
     * @return java.lang.Long
     */
    public Long leftPushAll(String key, List<Object> value) {
        return redisTemplate.opsForList().leftPushAll(key, value);
    }

    /**
     *  List存在的时候就加入新的值
     * @author chengjunyu
     * @date 2022/2/12
     * @param key
     * @param value
     * @return long
     */
    public long leftPushIfPresent(String key, Object value) {
        return redisTemplate.opsForList().leftPushIfPresent(key, value);
    }

    /**
     * 把值添加在 list的最后面
     * @author chengjunyu
     * @date 2022/2/12
     * @param key
     * @param value
     * @return java.lang.Long
     */
    public long rightPush(String key, Object value) {
        return redisTemplate.opsForList().rightPush(key, value);
    }

    /**
     *  把值添加在 list的最后面
     * @author chengjunyu
     * @date 2022/2/12
     * @param key
     * @param values
     * @return long
     */
    public long rightPushAll(String key, Object... values) {
        return redisTemplate.opsForList().rightPushAll(key, values);
    }

    /**
     *  把值添加在 list的最后面
     * @author chengjunyu
     * @date 2022/2/12
     * @param key
     * @param values
     * @return long
     */
    public long rightPushAll(String key, List<Object> values) {
        return redisTemplate.opsForList().rightPushAll(key, values);
    }

    /**
     *  根据索引获取 list中的值
     * @author chengjunyu
     * @date 2022/2/12
     * @param key
     * @param index
     * @return java.lang.Object
     */
    public Object index(String key, long index) {
        return redisTemplate.opsForList().index(key, index);
    }

    /**
     *  获取 list中开始索引到结束索引的所有值
     * @author chengjunyu
     * @date 2022/2/12
     * @param key
     * @param start
     * @param end
     * @return java.util.List<java.lang.Object>
     */
    public List<Object> range(String key, long start, long end) {
        return redisTemplate.opsForList().range(key, start, end);
    }

    /**
     *  移除并获取列表中第一个元素
     * @author chengjunyu
     * @date 2022/2/12
     * @param key
     * @return java.lang.Object
     */
    public Object leftPop(String key) {
        return redisTemplate.opsForList().leftPop(key);
    }

    /**
     *  移除并获取列表中第一个元素
     * @author chengjunyu
     * @date 2022/2/12
     * @param key
     * @param seconds
     * @param timeUnit
     * @return java.lang.Object
     */
    public Object leftPop(String key, Long seconds, TimeUnit timeUnit) {
        return redisTemplate.opsForList().leftPop(key, seconds, timeUnit);
    }

    /**
     *  移除并获取列表中最后一个元素
     * @author chengjunyu
     * @date 2022/2/12
     * @param key
     * @return java.lang.Object
     */
    public Object rightPop(String key) {
        return redisTemplate.opsForList().rightPop(key);
    }

    /**
     *  移除并获取列表中最后一个元素
     * @author chengjunyu
     * @date 2022/2/12
     * @param key
     * @param seconds
     * @param timeUnit
     * @return java.lang.Object
     */
    public Object rightPop(String key, Long seconds, TimeUnit timeUnit) {
        return redisTemplate.opsForList().rightPop(key, seconds, timeUnit);
    }

    /**
     *  从一个队列的右边弹出一个元素并将这个元素放入另一个指定队列的最左边
     * @author chengjunyu
     * @date 2022/2/12
     * @param sourceKey
     * @param destinationKey
     * @return java.lang.Object
     */
    public Object rightPopAndLeftPush(String sourceKey, String destinationKey) {
        return redisTemplate.opsForList().rightPopAndLeftPush(sourceKey, destinationKey);
    }

    /**
     *  从一个队列的右边弹出一个元素并将这个元素放入另一个指定队列的最左边
     * @author chengjunyu
     * @date 2022/2/12
     * @param sourceKey
     * @param destinationKey
     * @param seconds
     * @param timeUnit
     * @return java.lang.Object
     */
    public Object rightPopAndLeftPush(String sourceKey, String destinationKey, long seconds, TimeUnit timeUnit) {
        return redisTemplate.opsForList().rightPopAndLeftPush(sourceKey, destinationKey, seconds, timeUnit);
    }

    /**
     *  获取 list的大小
     * @author chengjunyu
     * @date 2022/2/12
     * @param key
     * @return java.lang.Long
     */
    public Long sizeList(String key) {
        return redisTemplate.opsForList().size(key);
    }

    /**
     *  剪裁 List列表
     * @author chengjunyu
     * @date 2022/2/12
     * @param key
     * @param start
     * @param end
     * @return void
     */
    public void trim(String key, long start, long end) {
        redisTemplate.opsForList().trim(key, start, end);
    }

    /**
     *  删除集合中值等于value的元素
     * @author chengjunyu
     * @date 2022/2/12
     * @param key
     * @param index
     * @param value
     * @return java.lang.Long
     */
    public Long remove(String key, long index, Object value) {
        return redisTemplate.opsForList().remove(key, index, value);
    }

    /**
     *  添加元素到 set中
     * @author chengjunyu
     * @date 2022/2/12
     * @param key
     * @param values
     * @return java.lang.Long
     */
    public Long add(String key, Collection<Object> values) {
        return redisTemplate.opsForSet().add(key, values);
    }

    /**
     *  从 set中删除一个随机元素，并返回该元素
     * @author chengjunyu
     * @date 2022/2/12
     * @param key
     * @return java.lang.Object
     */
    public Object pop(String key) {
        return redisTemplate.opsForSet().pop(key);
    }

    /**
     *  获取 set集合的大小
     * @author chengjunyu
     * @date 2022/2/12
     * @param key
     * @return long
     */
    public Long sizeSet(String key) {
        return redisTemplate.opsForSet().size(key);
    }

    /**
     *  判断 set集合中是否存在value值
     * @author chengjunyu
     * @date 2022/2/12
     * @param key
     * @param value
     * @return java.lang.Boolean
     */
    public Boolean isMember(String key, Object value) {
        return redisTemplate.opsForSet().isMember(key, value);
    }

    /**
     *  获取两个集合的交集并返回一个集合
     * @author chengjunyu
     * @date 2022/2/12
     * @param key
     * @param otherKey
     * @return java.util.Set<java.lang.Object>
     */
    public Set<Object> intersect(String key, String otherKey) {
        return redisTemplate.opsForSet().intersect(key, otherKey);
    }

    /**
     *  获取两个集合的交集并返回一个集合
     * @author chengjunyu
     * @date 2022/2/12
     * @param key
     * @param collection
     * @return java.util.Set<java.lang.Object>
     */
    public Set<Object> intersect(String key, Collection<String> collection) {
        return redisTemplate.opsForSet().intersect(key, collection);
    }

    /**
     *  获取两个集合交集，并存储到 destKey
     * @author chengjunyu
     * @date 2022/2/12
     * @param key1
     * @param key2
     * @param destKey
     * @return java.lang.Long
     */
    public Long intersectAndStore(String key1, String key2, String destKey) {
        return redisTemplate.opsForSet().intersectAndStore(key1, key2, destKey);
    }

    /**
     *  获取两个集合的并集
     * @author chengjunyu
     * @date 2022/2/12
     * @param key
     * @param key1
     * @return java.util.Set<java.lang.Object>
     */
    public Set<Object> union(String key, String key1) {
        return redisTemplate.opsForSet().union(key, key1);
    }

    /**
     *  获取两个集合的并集
     * @author chengjunyu
     * @date 2022/2/12
     * @param key
     * @param collection
     * @return java.util.Set<java.lang.Object>
     */
    public Set<Object> union(String key, Collection<String> collection) {
        return redisTemplate.opsForSet().union(key, collection);
    }

    /**
     *  获取两个集合的并集，并存储到 destKey
     * @author chengjunyu
     * @date 2022/2/12
     * @param key
     * @param key1
     * @param destKey
     * @return java.lang.Long
     */
    public Long unionAndStore(String key, String key1, String destKey) {
        return redisTemplate.opsForSet().unionAndStore(key, key1, destKey);
    }

    /**
     *  获取两个集合的差集
     * @author chengjunyu
     * @date 2022/2/12
     * @param key
     * @param key1
     * @return java.util.Set<java.lang.Object>
     */
    public Set<Object> difference(String key, String key1) {
        return redisTemplate.opsForSet().difference(key, key1);
    }

    /**
     *  获取两个集合的差集
     * @author chengjunyu
     * @date 2022/2/12
     * @param key
     * @param collection
     * @return java.util.Set<java.lang.Object>
     */
    public Set<Object> difference(String key, Collection<String> collection) {
        return redisTemplate.opsForSet().difference(key, collection);
    }

    /**
     *  获取两个集合的差集，并存储到 destKey
     * @author chengjunyu
     * @date 2022/2/12
     * @param key
     * @param key1
     * @param destKey
     * @return java.lang.Long
     */
    public Long differenceAndStore(String key, String key1, String destKey) {
        return redisTemplate.opsForSet().differenceAndStore(key, key1, destKey);
    }

    /**
     *  获取集合中的所有元素
     * @author chengjunyu
     * @date 2022/2/12
     * @param key
     * @return java.util.Set<java.lang.Object>
     */
    public Set<Object> members(String key) {
        return redisTemplate.opsForSet().members(key);
    }

    /**
     *  随机获取集合中一个元素
     * @author chengjunyu
     * @date 2022/2/12
     * @param key
     * @return java.lang.Object
     */
    public Object randomMember(String key) {
        return redisTemplate.opsForSet().randomMember(key);
    }

    /**
     *  随机获取集合中 count个元素，返回一个 List集合
     * @author chengjunyu
     * @date 2022/2/12
     * @param key
     * @param count
     * @return java.util.List<java.lang.Object>
     */
    public List<Object> randomMembers(String key, long count) {
        return redisTemplate.opsForSet().randomMembers(key, count);
    }

    /**
     *  随机获取集合中 count个元素，去重后返回一个 Set集合
     * @author chengjunyu
     * @date 2022/2/12
     * @param key
     * @param count
     * @return java.util.Set<java.lang.Object>
     */
    public Set<Object> distinctRandomMembers(String key, long count) {
        return redisTemplate.opsForSet().distinctRandomMembers(key, count);
    }

    /**
     *  遍历 set
     * @author chengjunyu
     * @date 2022/2/12
     * @param key
     * @param scanOptions
     * @return org.springframework.data.redis.core.Cursor<java.lang.Object>
     */
    public Cursor<Object> scanSet(String key, ScanOptions scanOptions) {
        return redisTemplate.opsForSet().scan(key, scanOptions);
    }

    /**
     *  移除元素
     * @author chengjunyu
     * @date 2022/2/12
     * @param key
     * @param objects
     * @return java.lang.Long
     */
    public Long remove(String key, Collection<Object> objects) {
        return redisTemplate.opsForSet().remove(key, objects);
    }

    /**
     *  添加元素到 zset，从小到大排序
     * @author chengjunyu
     * @date 2022/2/12
     * @param key
     * @param value
     * @param score
     * @return java.lang.Boolean
     */
    public Boolean add(String key, Object value, double score) {
        return redisTemplate.opsForZSet().add(key, value, score);
    }

    /**
     *  增加元素的 score值同时返回增加后的 score值
     * @author chengjunyu
     * @date 2022/2/12
     * @param key
     * @param value
     * @param score
     * @return java.lang.Double
     */
    public Double incrementScore(String key, Object value, double score) {
        return redisTemplate.opsForZSet().incrementScore(key, value, score);
    }

    /**
     *  返回 zset元素在集合的从小到大排名
     * @author chengjunyu
     * @date 2022/2/12
     * @param key
     * @param object
     * @return java.lang.Long
     */
    public Long rank(String key, Object object) {
        return redisTemplate.opsForZSet().rank(key, object);
    }

    /**
     *  返回 zset元素在集合的由大到小排名
     * @author chengjunyu
     * @date 2022/2/12
     * @param key
     * @param object
     * @return java.lang.Long
     */
    public Long reverseRank(String key, Object object) {
        return redisTemplate.opsForZSet().reverseRank(key, object);
    }

    /**
     *  获取 zset集合中指定区间的元素
     * @author chengjunyu
     * @date 2022/2/12
     * @param key
     * @param start
     * @param end
     * @return java.util.Set<org.springframework.data.redis.core.ZSetOperations.TypedTuple<java.lang.Object>>
     */
    public Set<ZSetOperations.TypedTuple<Object>> reverseRangeWithScores(String key, long start, long end) {
        return redisTemplate.opsForZSet().reverseRangeWithScores(key, start, end);
    }

    /**
     *  查询 zset集合中的元素并从小到大排序
     * @author chengjunyu
     * @date 2022/2/12
     * @param key
     * @param min
     * @param max
     * @return java.util.Set<java.lang.Object>
     */
    public Set<Object> reverseRangeByScore(String key, double min, double max) {
        return redisTemplate.opsForZSet().reverseRangeByScore(key, min, max);
    }

    /**
     *  从高到低进行排序，然后获取最小与最大值之间的值
     * @author chengjunyu
     * @date 2022/2/12
     * @param key
     * @param min
     * @param max
     * @param start
     * @param end
     * @return java.util.Set<java.lang.Object>
     */
    public Set<Object> reverseRangeByScore(String key, double min, double max, long start, long end) {
        return redisTemplate.opsForZSet().reverseRangeByScore(key, min, max, start, end);
    }

    /**
     *  查询 zset集合中的元素并从小到大排序
     * @author chengjunyu
     * @date 2022/2/12
     * @param key
     * @param min
     * @param max
     * @return java.util.Set<org.springframework.data.redis.core.ZSetOperations.TypedTuple<java.lang.Object>>
     */
    public Set<ZSetOperations.TypedTuple<Object>> reverseRangeByScoreWithScores(String key, double min, double max) {
        return redisTemplate.opsForZSet().reverseRangeByScoreWithScores(key, min, max);
    }

    /**
     *  根据score值获取元素数量
     * @author chengjunyu
     * @date 2022/2/12
     * @param key
     * @param min
     * @param max
     * @return java.lang.Long
     */
    public Long count(String key, double min, double max) {
        return redisTemplate.opsForZSet().count(key, min, max);
    }

    /**
     *  获取 zset集合的大小
     * @author chengjunyu
     * @date 2022/2/12
     * @param key
     * @return java.lang.Long
     */
    public Long sizeZset(String key) {
        return redisTemplate.opsForZSet().size(key);
    }

    /**
     *  获取 zset集合的大小
     * @author chengjunyu
     * @date 2022/2/12
     * @param key
     * @return java.lang.Long
     */
    public Long zCard(String key) {
        return redisTemplate.opsForZSet().zCard(key);
    }

    /**
     *  获取集合中 key、value元素的 score值
     * @author chengjunyu
     * @date 2022/2/12
     * @param key
     * @param value
     * @return java.lang.Double
     */
    public Double score(String key, Object value) {
        return redisTemplate.opsForZSet().score(key, value);
    }

    /**
     *  移除 zset中指定索引元素
     * @author chengjunyu
     * @date 2022/2/12
     * @param key
     * @param start
     * @param end
     * @return java.lang.Long
     */
    public Long removeRange(String key, long start, long end) {
        return redisTemplate.opsForZSet().removeRange(key, start, end);
    }

    /**
     *  移除 zset中指定 score范围的集合成员
     * @author chengjunyu
     * @date 2022/2/12
     * @param key
     * @param min
     * @param max
     * @return java.lang.Long
     */
    public Long removeRangeByScore(String key, double min, double max) {
        return redisTemplate.opsForZSet().removeRangeByScore(key, min, max);
    }

    /**
     *  获取 key和 key1的并集并存储在 destKey中
     * @author chengjunyu
     * @date 2022/2/12
     * @param key
     * @param key1
     * @param destKey
     * @return java.lang.Long
     */
    public Long zSetUnionAndStore(String key, String key1, String destKey) {
        return redisTemplate.opsForZSet().unionAndStore(key, key1, destKey);
    }

    /**
     *  获取 key和 collection集合的并集并存储在 destKey中
     * @author chengjunyu
     * @date 2022/2/12
     * @param key
     * @param collection
     * @param destKey
     * @return java.lang.Long
     */
    public Long zSetUnionAndStore(String key, Collection<String> collection, String destKey) {
        return redisTemplate.opsForZSet().unionAndStore(key, collection, destKey);
    }

    /**
     *  获取 key和 key1的交集并存储在 destKey中
     * @author chengjunyu
     * @date 2022/2/12
     * @param key
     * @param key1
     * @param destKey
     * @return java.lang.Long
     */
    public Long zSetIntersectAndStore(String key, String key1, String destKey) {
        return redisTemplate.opsForZSet().intersectAndStore(key, key1, destKey);
    }

    /**
     *  获取 key和 collection集合的交集并存储在 destKey中
     * @author chengjunyu
     * @date 2022/2/12
     * @param key
     * @param collection
     * @param destKey
     * @return java.lang.Long
     */
    public Long zSetIntersectAndStore(String key, Collection<String> collection, String destKey) {
        return redisTemplate.opsForZSet().intersectAndStore(key, collection, destKey);
    }

    /**
     *  删除多个values的值
     * @author chengjunyu
     * @date 2022/2/12
     * @param key
     * @param values
     * @return java.lang.Long
     */
    public Long remove(String key, Object... values) {
        return redisTemplate.opsForZSet().remove(key, values);
    }
}
